/**
 * API接口模拟服务
 * 在开发阶段模拟后端接口，便于前端开发和测试
 */

import { post, get } from './request.js'

// 模拟数据存储（实际项目中这些数据应该存储在后端数据库）
const MOCK_USERS = [
  {
    id: 1,
    phone: '13800138000',
    account: 'admin',
    password: '123456',
    name: '管理员',
    avatar: '',
    createTime: '2024-01-01 10:00:00'
  },
  {
    id: 2,
    phone: '13800138001',
    account: 'user01',
    password: '123456',
    name: '张三',
    avatar: '',
    createTime: '2024-01-02 10:00:00'
  }
]

// 模拟验证码存储
const MOCK_SMS_CODES = new Map()

/**
 * 模拟网络延迟
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {Promise} 延迟Promise
 */
function mockDelay(delay = 1000) {
  return new Promise(resolve => setTimeout(resolve, delay))
}

/**
 * 生成随机验证码
 * @returns {string} 6位数字验证码
 */
function generateSmsCode() {
  return Math.random().toString().slice(-6)
}

/**
 * 生成JWT Token（模拟）
 * @param {Object} payload - 载荷数据
 * @returns {string} 模拟token
 */
function generateToken(payload) {
  const header = btoa(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
  const payloadStr = btoa(JSON.stringify({ ...payload, exp: Date.now() + 7 * 24 * 60 * 60 * 1000 }))
  const signature = btoa(`mock_signature_${Date.now()}`)
  return `${header}.${payloadStr}.${signature}`
}

/**
 * 用户认证相关接口
 */
export const authApi = {
  /**
   * 用户登录
   * @param {Object} params - 登录参数
   * @param {string} params.account - 账号（手机号或用户名）
   * @param {string} params.password - 密码
   * @returns {Promise} 登录结果
   */
  async login(params) {
    const { account, password } = params
    
    // 模拟网络延迟
    await mockDelay(1500)
    
    // 查找用户
    const user = MOCK_USERS.find(u => 
      u.account === account || u.phone === account
    )
    
    if (!user) {
      throw new Error('账号不存在')
    }
    
    if (user.password !== password) {
      throw new Error('密码错误')
    }
    
    // 生成token
    const token = generateToken({
      userId: user.id,
      account: user.account,
      phone: user.phone
    })
    
    return {
      code: 0,
      message: '登录成功',
      data: {
        token,
        userInfo: {
          id: user.id,
          account: user.account,
          name: user.name,
          phone: user.phone,
          avatar: user.avatar
        }
      }
    }
  },

  /**
   * 用户注册
   * @param {Object} params - 注册参数
   * @param {string} params.phone - 手机号
   * @param {string} params.verificationCode - 验证码
   * @param {string} params.password - 密码
   * @returns {Promise} 注册结果
   */
  async register(params) {
    const { phone, verificationCode, password } = params
    
    // 模拟网络延迟
    await mockDelay(2000)
    
    // 验证手机号格式
    if (!/^1[3-9]\d{9}$/.test(phone)) {
      throw new Error('手机号格式不正确')
    }
    
    // 检查手机号是否已注册
    const existUser = MOCK_USERS.find(u => u.phone === phone)
    if (existUser) {
      throw new Error('该手机号已注册')
    }
    
    // 验证验证码
    const storedCode = MOCK_SMS_CODES.get(phone)
    if (!storedCode || storedCode !== verificationCode) {
      throw new Error('验证码错误或已过期')
    }
    
    // 验证密码强度
    if (password.length < 6) {
      throw new Error('密码长度不能少于6位')
    }
    
    // 创建新用户
    const newUser = {
      id: MOCK_USERS.length + 1,
      phone,
      account: `user${Date.now()}`,
      password,
      name: `用户${phone.slice(-4)}`,
      avatar: '',
      createTime: new Date().toLocaleString()
    }
    
    MOCK_USERS.push(newUser)
    
    // 清除验证码
    MOCK_SMS_CODES.delete(phone)
    
    return {
      code: 0,
      message: '注册成功',
      data: {
        userId: newUser.id
      }
    }
  },

  /**
   * 忘记密码 - 重置密码
   * @param {Object} params - 重置密码参数
   * @param {string} params.phone - 手机号
   * @param {string} params.verificationCode - 验证码
   * @param {string} params.newPassword - 新密码
   * @returns {Promise} 重置结果
   */
  async resetPassword(params) {
    const { phone, verificationCode, newPassword } = params
    
    // 模拟网络延迟
    await mockDelay(1800)
    
    // 查找用户
    const userIndex = MOCK_USERS.findIndex(u => u.phone === phone)
    if (userIndex === -1) {
      throw new Error('该手机号未注册')
    }
    
    // 验证验证码
    const storedCode = MOCK_SMS_CODES.get(phone)
    if (!storedCode || storedCode !== verificationCode) {
      throw new Error('验证码错误或已过期')
    }
    
    // 验证新密码
    if (newPassword.length < 6) {
      throw new Error('密码长度不能少于6位')
    }
    
    // 更新密码
    MOCK_USERS[userIndex].password = newPassword
    
    // 清除验证码
    MOCK_SMS_CODES.delete(phone)
    
    return {
      code: 0,
      message: '密码重置成功',
      data: null
    }
  },

  /**
   * 发送短信验证码
   * @param {Object} params - 发送参数
   * @param {string} params.phone - 手机号
   * @param {string} params.type - 验证码类型（register|reset|login）
   * @returns {Promise} 发送结果
   */
  async sendSmsCode(params) {
    const { phone, type = 'register' } = params
    
    // 模拟网络延迟
    await mockDelay(1000)
    
    // 验证手机号格式
    if (!/^1[3-9]\d{9}$/.test(phone)) {
      throw new Error('手机号格式不正确')
    }
    
    // 根据类型检查手机号状态
    const existUser = MOCK_USERS.find(u => u.phone === phone)
    
    if (type === 'register' && existUser) {
      throw new Error('该手机号已注册')
    }
    
    if ((type === 'reset' || type === 'login') && !existUser) {
      throw new Error('该手机号未注册')
    }
    
    // 生成验证码
    const code = generateSmsCode()
    
    // 存储验证码（实际项目中应该设置过期时间）
    MOCK_SMS_CODES.set(phone, code)
    
    // 模拟发送短信（实际项目中调用短信服务商API）
    console.log(`发送验证码到 ${phone}: ${code}`)
    
    return {
      code: 0,
      message: '验证码发送成功',
      data: {
        codeKey: `sms_${phone}_${Date.now()}`,
        // 开发环境返回验证码，生产环境不应该返回
        debugCode: process.env.NODE_ENV === 'development' ? code : undefined
      }
    }
  },

  /**
   * 验证Token有效性
   * @param {string} token - JWT Token
   * @returns {Promise} 验证结果
   */
  async verifyToken(token) {
    // 模拟网络延迟
    await mockDelay(500)
    
    if (!token) {
      throw new Error('Token不能为空')
    }
    
    try {
      // 简单的Token解析（实际项目中需要验证签名）
      const parts = token.split('.')
      if (parts.length !== 3) {
        throw new Error('Token格式错误')
      }
      
      const payload = JSON.parse(atob(parts[1]))
      
      // 检查过期时间
      if (payload.exp && payload.exp < Date.now()) {
        throw new Error('Token已过期')
      }
      
      // 查找用户
      const user = MOCK_USERS.find(u => u.id === payload.userId)
      if (!user) {
        throw new Error('用户不存在')
      }
      
      return {
        code: 0,
        message: 'Token有效',
        data: {
          userInfo: {
            id: user.id,
            account: user.account,
            name: user.name,
            phone: user.phone,
            avatar: user.avatar
          }
        }
      }
    } catch (error) {
      throw new Error('Token无效')
    }
  },

  /**
   * 退出登录
   * @returns {Promise} 退出结果
   */
  async logout() {
    // 模拟网络延迟
    await mockDelay(500)
    
    return {
      code: 0,
      message: '退出成功',
      data: null
    }
  }
}

/**
 * 用户信息相关接口
 */
export const userApi = {
  /**
   * 获取用户信息
   * @returns {Promise} 用户信息
   */
  async getUserInfo() {
    // 模拟网络延迟
    await mockDelay(800)
    
    // 实际项目中从token中获取用户ID，然后查询数据库
    const token = uni.getStorageSync('token')
    if (!token) {
      throw new Error('未登录')
    }
    
    return {
      code: 0,
      message: '获取成功',
      data: {
        id: 1,
        account: 'demo_user',
        name: '演示用户',
        phone: '13800138000',
        avatar: '',
        createTime: '2024-01-01 10:00:00'
      }
    }
  },

  /**
   * 更新用户信息
   * @param {Object} params - 更新参数
   * @returns {Promise} 更新结果
   */
  async updateUserInfo(params) {
    // 模拟网络延迟
    await mockDelay(1200)
    
    return {
      code: 0,
      message: '更新成功',
      data: null
    }
  }
}

// 统一导出
export default {
  authApi,
  userApi
}